home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / Main.bin / IndexedPropertyDescriptor.java < prev    next >
Text File  |  1998-09-22  |  9KB  |  227 lines
  1. /*
  2.  * @(#)IndexedPropertyDescriptor.java    1.24 98/07/01
  3.  *
  4.  * Copyright 1996-1998 by Sun Microsystems, Inc.,
  5.  * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
  6.  * All rights reserved.
  7.  * 
  8.  * This software is the confidential and proprietary information
  9.  * of Sun Microsystems, Inc. ("Confidential Information").  You
  10.  * shall not disclose such Confidential Information and shall use
  11.  * it only in accordance with the terms of the license agreement
  12.  * you entered into with Sun.
  13.  */
  14.  
  15. package java.beans;
  16.  
  17. import java.lang.reflect.*;
  18.  
  19. /**
  20.  * An IndexedPropertyDescriptor describes a property that acts like an
  21.  * array and has an indexed read and/or indexed write method to access
  22.  * specific elements of the array.
  23.  * <p>
  24.  * An indexed property may also provide simple non-indexed read and write
  25.  * methods.  If these are present, they read and write arrays of the type
  26.  * returned by the indexed read method.
  27.  */
  28.  
  29. public class IndexedPropertyDescriptor extends PropertyDescriptor {
  30.  
  31.     /**
  32.      * This constructor constructs an IndexedPropertyDescriptor for a property
  33.      * that follows the standard Java conventions by having getFoo and setFoo 
  34.      * accessor methods, for both indexed access and array access.
  35.      * <p>
  36.      * Thus if the argument name is "fred", it will assume that there
  37.      * is an indexed reader method "getFred", a non-indexed (array) reader
  38.      * method also called "getFred", an indexed writer method "setFred",
  39.      * and finally a non-indexed writer method "setFred".
  40.      *
  41.      * @param propertyName The programmatic name of the property.
  42.      * @param beanClass The Class object for the target bean.
  43.      * @exception IntrospectionException if an exception occurs during
  44.      *              introspection.
  45.      */
  46.     public IndexedPropertyDescriptor(String propertyName, Class beanClass)
  47.         throws IntrospectionException {
  48.     this(propertyName, beanClass,
  49.              "get" + capitalize(propertyName),
  50.              "set" + capitalize(propertyName),
  51.              "get" + capitalize(propertyName),
  52.              "set" + capitalize(propertyName));
  53.     }
  54.  
  55.     /**
  56.      * This constructor takes the name of a simple property, and method
  57.      * names for reading and writing the property, both indexed
  58.      * and non-indexed.
  59.      *
  60.      * @param propertyName The programmatic name of the property.
  61.      * @param beanClass  The Class object for the target bean.
  62.      * @param getterName The name of the method used for reading the property
  63.      *         values as an array.  May be null if the property is write-only
  64.      *         or must be indexed.
  65.      * @param setterName The name of the method used for writing the property
  66.      *         values as an array.  May be null if the property is read-only
  67.      *         or must be indexed.
  68.      * @param indexedGetterName The name of the method used for reading
  69.      *        an indexed property value.
  70.      *        May be null if the property is write-only.
  71.      * @param indexedSetterName The name of the method used for writing
  72.      *        an indexed property value.  
  73.      *        May be null if the property is read-only.
  74.      * @exception IntrospectionException if an exception occurs during
  75.      *              introspection.
  76.      */
  77.     public IndexedPropertyDescriptor(String propertyName, Class beanClass,
  78.         String getterName, String setterName,
  79.         String indexedGetterName, String indexedSetterName)
  80.         throws IntrospectionException {
  81.     super(propertyName, beanClass, getterName, setterName);
  82.     indexedReadMethod = Introspector.findMethod(beanClass, indexedGetterName, 1);
  83.     indexedWriteMethod = Introspector.findMethod(beanClass, indexedSetterName, 2);
  84.     findIndexedPropertyType();
  85.     }
  86.  
  87.     /**
  88.      * This constructor takes the name of a simple property, and Method
  89.      * objects for reading and writing the property.
  90.      *
  91.      * @param propertyName The programmatic name of the property.
  92.      * @param getter The method used for reading the property values as an array.
  93.      *        May be null if the property is write-only or must be indexed.
  94.      * @param setter The method used for writing the property values as an array.
  95.      *        May be null if the property is read-only or must be indexed.
  96.      * @param indexedGetter The method used for reading an indexed property value.
  97.      *        May be null if the property is write-only.
  98.      * @param indexedSetter The method used for writing an indexed property value.  
  99.      *        May be null if the property is read-only.
  100.      * @exception IntrospectionException if an exception occurs during
  101.      *              introspection.
  102.      */
  103.     public IndexedPropertyDescriptor(String propertyName, Method getter, Method setter,
  104.                          Method indexedGetter, Method indexedSetter)
  105.         throws IntrospectionException {
  106.     super(propertyName, getter, setter);
  107.     indexedReadMethod = indexedGetter;
  108.     indexedWriteMethod = indexedSetter;
  109.     findIndexedPropertyType();
  110.     }
  111.     
  112.     /**
  113.      * @return The method that should be used to read an indexed
  114.      * property value.
  115.      * May return null if the property isn't indexed or is write-only.
  116.      */
  117.     public Method getIndexedReadMethod() {
  118.     return indexedReadMethod;
  119.     }
  120.  
  121.     /**
  122.      * @return The method that should be used to write an indexed
  123.      * property value.
  124.      * May return null if the property isn't indexed or is read-only.
  125.      */
  126.     public Method getIndexedWriteMethod() {
  127.     return indexedWriteMethod;
  128.     }
  129.  
  130.     /**
  131.      * @return The Java Class for the indexed properties type.  Note that
  132.      * the Class may describe a primitive Java type such as "int".
  133.      * <p>
  134.      * This is the type that will be returned by the indexedReadMethod.
  135.      */
  136.     public Class getIndexedPropertyType() {
  137.     return indexedPropertyType;
  138.     }
  139.  
  140.  
  141.     private void findIndexedPropertyType() throws IntrospectionException {
  142.     try {
  143.         indexedPropertyType = null;
  144.         if (indexedReadMethod != null) {
  145.         Class params[] = indexedReadMethod.getParameterTypes();
  146.         if (params.length != 1) {
  147.             throw new IntrospectionException("bad indexed read method arg count");
  148.         }
  149.         if (params[0] != Integer.TYPE) {
  150.             throw new IntrospectionException("non int index to indexed read method");
  151.         }
  152.         indexedPropertyType = indexedReadMethod.getReturnType();
  153.         if (indexedPropertyType == Void.TYPE) {
  154.             throw new IntrospectionException("indexed read method returns void");
  155.         }
  156.         }
  157.         if (indexedWriteMethod != null) {
  158.         Class params[] = indexedWriteMethod.getParameterTypes();
  159.         if (params.length != 2) {
  160.             throw new IntrospectionException("bad indexed write method arg count");
  161.         }
  162.         if (params[0] != Integer.TYPE) {
  163.             throw new IntrospectionException("non int index to indexed write method");
  164.         }
  165.         if (indexedPropertyType != null && indexedPropertyType != params[1]) {
  166.             throw new IntrospectionException(
  167.             "type mismatch between indexed read and indexed write methods");
  168.         }
  169.         indexedPropertyType = params[1];
  170.         }
  171.         if (indexedPropertyType == null) {
  172.             throw new IntrospectionException(
  173.             "no indexed getter or setter");
  174.         }
  175.         Class propertyType = getPropertyType();
  176.         if (propertyType != null && (!propertyType.isArray() ||
  177.             propertyType.getComponentType() != indexedPropertyType)) {
  178.             throw new IntrospectionException(
  179.             "type mismatch between indexed and non-indexed methods");
  180.         }
  181.     } catch (IntrospectionException ex) {
  182.         throw ex;
  183.     }
  184.     }
  185.  
  186.  
  187.     /*
  188.      * Package-private constructor.
  189.      * Merge two property descriptors.  Where they conflict, give the
  190.      * second argument (y) priority over the first argumnnt (x).
  191.      * @param x  The first (lower priority) PropertyDescriptor
  192.      * @param y  The second (higher priority) PropertyDescriptor
  193.      */
  194.  
  195.     IndexedPropertyDescriptor(PropertyDescriptor x, PropertyDescriptor y) {
  196.     super(x,y);
  197.     if (x instanceof IndexedPropertyDescriptor) {
  198.         IndexedPropertyDescriptor ix = (IndexedPropertyDescriptor)x;
  199.         indexedReadMethod = ix.indexedReadMethod;
  200.         indexedWriteMethod = ix.indexedWriteMethod;
  201.         indexedPropertyType = ix.indexedPropertyType;
  202.     }
  203.     if (y instanceof IndexedPropertyDescriptor) {
  204.         IndexedPropertyDescriptor iy = (IndexedPropertyDescriptor)y;
  205.         if (iy.indexedReadMethod != null) {
  206.             indexedReadMethod = iy.indexedReadMethod;
  207.         }
  208.         if (iy.indexedWriteMethod != null) {
  209.             indexedWriteMethod = iy.indexedWriteMethod;
  210.         }
  211.         indexedPropertyType = iy.indexedPropertyType;
  212.     }
  213.     
  214.     }
  215.  
  216.  
  217.     private static String capitalize(String s) {
  218.     char chars[] = s.toCharArray();
  219.     chars[0] = Character.toUpperCase(chars[0]);
  220.     return new String(chars);
  221.     }
  222.  
  223.     private Class indexedPropertyType;
  224.     private Method indexedReadMethod;
  225.     private Method indexedWriteMethod;
  226. }
  227.